package com.teacher.game.framework.animation;

/**
 * UI动画控制器
 * 
 * 管理单个UI组件的属性动画生命周期，支持启动、暂停、停止、重复等操作。
 * 可以同时控制多个属性的动画（如同时改变透明度和位置）。
 * 
 * 核心特性：
 * - 属性动画：支持透明度、位置、缩放、旋转等
 * - 插值器：支持多种动画曲线（线性、缓入缓出、弹跳等）
 * - 生命周期管理：完整的启动/暂停/停止/重复控制
 * - 回调支持：动画开始、结束、重复等事件回调
 * 
 * 使用示例：
 * <pre>
 * UIAnimator animator = new UIAnimator(button)
 *     .animate("alpha", 0f, 1f, 1.0f, Tween.EASE_IN_OUT)
 *     .animate("y", 100f, 200f, 1.0f, Tween.BOUNCE)
 *     .setOnAnimationEndListener(() -> Log.d("Anim", "完成"))
 *     .start();
 * </pre>
 * 
 * @version 1.0
 * @since 2025-09-12
 */
public class UIAnimator {
    
    /**
     * 动画状态枚举
     */
    public enum State {
        IDLE,      // 空闲状态
        RUNNING,   // 运行中
        PAUSED,    // 已暂停
        FINISHED   // 已结束
    }
    
    /**
     * 动画监听器接口
     */
    public interface AnimationListener {
        default void onAnimationStart(UIAnimator animator) {}
        default void onAnimationEnd(UIAnimator animator) {}
        default void onAnimationCancel(UIAnimator animator) {}
        default void onAnimationRepeat(UIAnimator animator) {}
        default void onAnimationUpdate(UIAnimator animator, String property, float value) {}
    }
    
    // 核心属性
    private UIAnimatable target;           // 动画目标对象
    private State currentState;            // 当前状态
    private float currentTime;             // 当前时间
    private float totalDuration;           // 总持续时间
    
    // 动画配置
    private boolean isRepeating;           // 是否重复播放
    private int repeatCount;              // 重复次数(-1为无限)
    private int currentRepeatCount;       // 当前重复计数
    private float startDelay;             // 启动延迟
    
    // 补间动画数组（支持多属性同时动画）
    private java.util.List<PropertyTween> propertyTweens;
    
    // 监听器
    private AnimationListener listener;
    
    /**
     * 属性补间动画内部类
     */
    private static class PropertyTween {
        String property;
        Tween tween;
        float initialValue;
        
        PropertyTween(String property, Tween tween) {
            this.property = property;
            this.tween = tween;
        }
    }
    
    /**
     * 构造UI动画控制器
     * 
     * @param target 动画目标对象
     */
    public UIAnimator(UIAnimatable target) {
        this.target = target;
        this.currentState = State.IDLE;
        this.propertyTweens = new java.util.ArrayList<>();
        this.currentTime = 0f;
        this.totalDuration = 0f;
        this.repeatCount = 0;
        this.currentRepeatCount = 0;
        this.startDelay = 0f;
    }
    
    /**
     * 添加属性动画
     * 
     * @param property 属性名称
     * @param startValue 起始值
     * @param endValue 结束值
     * @param duration 持续时间（秒）
     * @param interpolationType 插值类型
     * @return 当前动画器（支持链式调用）
     */
    public UIAnimator animate(String property, float startValue, float endValue, 
                             float duration, int interpolationType) {
        if (!target.supportsProperty(property)) {
            throw new IllegalArgumentException("目标对象不支持属性: " + property);
        }
        
        Tween tween = new Tween(startValue, endValue, duration, interpolationType);
        PropertyTween propertyTween = new PropertyTween(property, tween);
        propertyTweens.add(propertyTween);
        
        // 更新总持续时间
        totalDuration = Math.max(totalDuration, duration);
        
        return this;
    }
    
    /**
     * 设置启动延迟
     * 
     * @param delay 延迟时间（秒）
     * @return 当前动画器
     */
    public UIAnimator setStartDelay(float delay) {
        this.startDelay = delay;
        return this;
    }
    
    /**
     * 设置重复播放
     * 
     * @param repeatCount 重复次数（-1为无限重复）
     * @return 当前动画器
     */
    public UIAnimator setRepeatCount(int repeatCount) {
        this.repeatCount = repeatCount;
        this.isRepeating = repeatCount != 0;
        return this;
    }
    
    /**
     * 设置动画监听器
     * 
     * @param listener 监听器
     * @return 当前动画器
     */
    public UIAnimator setAnimationListener(AnimationListener listener) {
        this.listener = listener;
        return this;
    }
    
    /**
     * 启动动画
     * 
     * @return 当前动画器
     */
    public UIAnimator start() {
        if (currentState == State.RUNNING) {
            return this;
        }
        
        currentState = State.RUNNING;
        currentTime = -startDelay; // 考虑启动延迟
        
        // 记录初始值
        for (PropertyTween propertyTween : propertyTweens) {
            propertyTween.initialValue = target.getAnimatedValue(propertyTween.property);
        }
        
        if (listener != null) {
            listener.onAnimationStart(this);
        }
        
        return this;
    }
    
    /**
     * 暂停动画
     */
    public void pause() {
        if (currentState == State.RUNNING) {
            currentState = State.PAUSED;
        }
    }
    
    /**
     * 恢复动画
     */
    public void resume() {
        if (currentState == State.PAUSED) {
            currentState = State.RUNNING;
        }
    }
    
    /**
     * 停止动画
     */
    public void stop() {
        currentState = State.FINISHED;
        if (listener != null) {
            listener.onAnimationCancel(this);
        }
    }
    
    /**
     * 更新动画状态
     * 
     * @param deltaTime 时间增量（秒）
     */
    public void update(float deltaTime) {
        if (currentState != State.RUNNING) {
            return;
        }
        
        currentTime += deltaTime;
        
        // 处理启动延迟
        if (currentTime < 0) {
            return;
        }
        
        // 检查是否完成
        if (currentTime >= totalDuration) {
            handleAnimationComplete();
            return;
        }
        
        // 更新所有属性
        for (PropertyTween propertyTween : propertyTweens) {
            float value = propertyTween.tween.getValueAtTime(currentTime);
            target.setAnimatedValue(propertyTween.property, value);
            
            if (listener != null) {
                listener.onAnimationUpdate(this, propertyTween.property, value);
            }
        }
    }
    
    /**
     * 处理动画完成
     */
    private void handleAnimationComplete() {
        // 确保设置为最终值
        for (PropertyTween propertyTween : propertyTweens) {
            target.setAnimatedValue(propertyTween.property, propertyTween.tween.getEndValue());
        }
        
        // 处理重复逻辑
        if (isRepeating && (repeatCount == -1 || currentRepeatCount < repeatCount)) {
            currentRepeatCount++;
            currentTime = 0f; // 重置时间
            
            if (listener != null) {
                listener.onAnimationRepeat(this);
            }
        } else {
            // 动画真正结束
            currentState = State.FINISHED;
            if (listener != null) {
                listener.onAnimationEnd(this);
            }
        }
    }
    
    // Getter方法
    public State getCurrentState() { return currentState; }
    public float getCurrentTime() { return currentTime; }
    public float getTotalDuration() { return totalDuration; }
    public boolean isRunning() { return currentState == State.RUNNING; }
    public boolean isFinished() { return currentState == State.FINISHED; }
    public float getProgress() { return totalDuration > 0 ? currentTime / totalDuration : 0; }
    
    /**
     * 重置动画到初始状态
     */
    public void reset() {
        currentState = State.IDLE;
        currentTime = 0f;
        currentRepeatCount = 0;
        
        // 恢复初始值
        for (PropertyTween propertyTween : propertyTweens) {
            target.setAnimatedValue(propertyTween.property, propertyTween.initialValue);
        }
    }
}